/** * 转换为Y-m-d格式 */
function formatDateToYYYYMMDD(days) {
  var date = new Date(days); // 创建一个新的Date对象，表示当前时间

  // 获取年份（注意getFullYear()返回的是四位数年份）
  var year = date.getFullYear();

  // 获取月份（注意getMonth()返回的是从0开始的月份，所以需要加1）
  var month = (1 + date.getMonth()).toString();
  month = month.length > 1 ? month : '0' + month; // 如果月份小于10，前面补0

  // 获取日期（注意getDate()返回的是从1开始的日期）
  var day = date.getDate().toString();
  day = day.length > 1 ? day : '0' + day; // 如果日期小于10，前面补0

  // 拼接字符串，得到YYYY-MM-DD格式的日期
  return year + '-' + month + '-' + day;
}
/** * 针对时间的工具类 */
function getDateAfterDays(days, format = 'yyyy-MM-dd hh:mm:ss') {
  // 创建一个新的Date对象，表示当前日期和时间
  const currentDate = new Date();

  // 增加指定的天数
  currentDate.setDate(currentDate.getDate() + days);

  // 自定义格式化函数
  function pad(num) {
    return num.toString().padStart(2, '0');
  }

  // 根据传入的格式字符串进行格式化
  const year = currentDate.getFullYear();
  const month = pad(currentDate.getMonth() + 1); // 月份是从0开始的，所以需要+1
  const day = pad(currentDate.getDate());
  const hours = pad(currentDate.getHours());
  const minutes = pad(currentDate.getMinutes());
  const seconds = pad(currentDate.getSeconds());

  // 根据格式字符串替换对应的值
  const formattedDate = format
    .replace('yyyy', year)
    .replace('MM', month)
    .replace('dd', day)
    .replace('hh', hours.toString().padStart(2, hours < 10 ? '0' : ' ')) // 12小时制需要额外处理
    .replace('mm', minutes)
    .replace('ss', seconds);

  return formattedDate;
}
/**
 * 参数：
 * 1. date: 秒级时间；
 * 2. fmt：格式化的格式 'yyyy', 'yyyy-MM-dd', 'yy-MM-dd', 'yyyy-MM-dd hh:mm:ss', ...(按需求自己定义格式)
 *       fmt给一个默认参数
 * RegExp.$1是正则对象里的内置符号，表示与 regexp 中的第1子表达式相匹配的文本。$2、...、$99同理
 * 注意年份与其他时间区分开，因为年份正常的表达是4位，所以单独判断
 */
function formatDate(date, fmt = 'yyyy-MM-dd hh:mm:ss') {
  if (typeof date === 'string') {
    return date;
  }
  date = new Date(date * 1000);
  const o = {
    'M+': date.getMonth() + 1, // 月份
    'd+': date.getDate(), // 日
    'h+': date.getHours(), // 时
    'm+': date.getMinutes(), // 分
    's+': date.getSeconds(), // 秒
    'q+': Math.floor((date.getMonth() + 3) / 3), // 季度
    S: date.getMilliseconds(), // 毫秒
  };

  if (!date || date == null) return null;

  if (/(y+)/.test(fmt))
    fmt = fmt.replace(RegExp.$1, (date.getFullYear() + '').substr(4 - RegExp.$1.length));
  for (const k in o) {
    if (new RegExp('(' + k + ')').test(fmt)) {
      fmt = fmt.replace(
        RegExp.$1,
        RegExp.$1.length === 1 ? o[k] : ('00' + o[k]).substr(('' + o[k]).length),
      );
    }
  }
  return fmt;
}
/** *     * 获得当前时间     */
export function getCurrentDate() {
  return new Date();
}
/* 获得昨天时间 */
export function getYesterday() {
  const day = new Date();
  day.setDate(day.getDate() - 1);
  return day;
}
/** *     * 获得本周起止时间     */
export function getCurrentWeek() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 返回date是一周中的某一天
  const week = currentDate.getDay();
  // 一天的毫秒数
  const millisecond = 1000 * 60 * 60 * 24;
  // 减去的天数
  const minusDay = week != 0 ? week - 1 : 6;
  // alert(minusDay);
  // 本周 周一
  const monday = new Date(currentDate.getTime() - minusDay * millisecond);
  // 本周 周日
  const sunday = new Date(monday.getTime() + 6 * millisecond);
  // 添加本周时间
  startStop.push(monday); // 本周起始时间
  // 添加本周最后一天时间
  startStop.push(sunday); // 本周终止时间
  // 返回
  return startStop;
}
/** *     * 获得本月的起止时间     */
export function getCurrentMonth() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 获得当前月份0-11
  let currentMonth = currentDate.getMonth();
  // 获得当前年份4位年
  let currentYear = currentDate.getFullYear();
  // 求出本月第一天
  const firstDay = new Date(currentYear, currentMonth, 1);
  // 当为12月的时候年份需要加1
  // 月份需要更新为0 也就是下一年的第一个月
  if (currentMonth == 11) {
    currentYear++;
    currentMonth = 0; // 就为
  } else {
    // 否则只是月份增加,以便求的下一月的第一天
    currentMonth++;
  }
  // 一天的毫秒数
  const millisecond = 1000 * 60 * 60 * 24;
  // 下月的第一天
  const nextMonthDayOne = new Date(currentYear, currentMonth, 1);
  // 求出上月的最后一天
  const lastDay = new Date(nextMonthDayOne.getTime() - millisecond);
  // 添加至数组中返回
  startStop.push(firstDay);
  startStop.push(lastDay);
  // 返回
  return startStop;
}
/**     * 得到本季度开始的月份     * @param month 需要计算的月份     ***/
export function getQuarterSeasonStartMonth(month) {
  const spring = 0; // 春
  const summer = 3; // 夏
  const fall = 6; // 秋
  const winter = 9; // 冬
  // 月份从0-11
  if (month < 3) {
    return spring;
  }
  if (month < 6) {
    return summer;
  }
  if (month < 9) {
    return fall;
  }
  return winter;
}
/**     * 获得该月的天数     * @param year年份     * @param month月份     * */
export function getMonthDays(year, month) {
  // 本月第一天 1-31
  const relativeDate = new Date(year, month, 1);
  // 获得当前月份0-11
  let relativeMonth = relativeDate.getMonth();
  // 获得当前年份4位年
  let relativeYear = relativeDate.getFullYear();
  // 当为12月的时候年份需要加1
  // 月份需要更新为0 也就是下一年的第一个月
  if (relativeMonth == 11) {
    relativeYear++;
    relativeMonth = 0;
  } else {
    // 否则只是月份增加,以便求的下一月的第一天
    relativeMonth++;
  }
  // 一天的毫秒数
  const millisecond = 1000 * 60 * 60 * 24;
  // 下月的第一天
  const nextMonthDayOne = new Date(relativeYear, relativeMonth, 1);
  // 返回得到上月的最后一天,也就是本月总天数
  return new Date(nextMonthDayOne.getTime() - millisecond).getDate();
}
/**     * 获得本季度的起止日期     */
export function getCurrentSeason() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 获得当前月份0-11
  const currentMonth = currentDate.getMonth();
  // 获得当前年份4位年
  const currentYear = currentDate.getFullYear();
  // 获得本季度开始月份
  const quarterSeasonStartMonth = getQuarterSeasonStartMonth(currentMonth);
  // 获得本季度结束月份
  const quarterSeasonEndMonth = quarterSeasonStartMonth + 2;
  // 获得本季度开始的日期
  const quarterSeasonStartDate = new Date(currentYear, quarterSeasonStartMonth, 1);
  // 获得本季度结束的日期
  const quarterSeasonEndDate = new Date(
    currentYear,
    quarterSeasonEndMonth,
    getMonthDays(currentYear, quarterSeasonEndMonth),
  );
  // 加入数组返回
  startStop.push(quarterSeasonStartDate);
  startStop.push(quarterSeasonEndDate);
  // 返回
  return startStop;
}
/** *     * 得到本年的起止日期     *     */
export function getCurrentYear() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 获得当前年份4位年
  const currentYear = currentDate.getFullYear();
  // 本年第一天
  const currentYearFirstDate = new Date(currentYear, 0, 1);
  // 本年最后一天
  const currentYearLastDate = new Date(currentYear, 11, 31);
  // 添加至数组
  startStop.push(currentYearFirstDate);
  startStop.push(currentYearLastDate);
  // 返回
  return startStop;
}
/**     * 返回上一个月的第一天Date类型     * @param year 年     * @param month 月     **/
export function getPriorMonthFirstDay(year, month) {
  // 年份为0代表,是本年的第一月,所以不能减
  if (month == 0) {
    month = 11;
    // 月份为上年的最后月份
    year--; // 年份减1
    return new Date(year, month, 1);
  }
  // 否则,只减去月份
  month--;
  return new Date(year, month, 1);
}
/**     * 获得上一月的起止日期     * ***/
export function getPreviousMonth() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 获得当前月份0-11
  const currentMonth = currentDate.getMonth();
  // 获得当前年份4位年
  const currentYear = currentDate.getFullYear();
  // 获得上一个月的第一天
  const priorMonthFirstDay = getPriorMonthFirstDay(currentYear, currentMonth);
  // 获得上一月的最后一天
  const priorMonthLastDay = new Date(
    priorMonthFirstDay.getFullYear(),
    priorMonthFirstDay.getMonth(),
    getMonthDays(priorMonthFirstDay.getFullYear(), priorMonthFirstDay.getMonth()),
  );
  // 添加至数组
  startStop.push(priorMonthFirstDay);
  startStop.push(priorMonthLastDay);
  // 返回
  return startStop;
}
/**     * 获得上一周的起止日期     * **/
export function getPreviousWeek() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 返回date是一周中的某一天
  const week = currentDate.getDay();
  // 一天的毫秒数
  const millisecond = 1000 * 60 * 60 * 24;
  // 减去的天数
  const minusDay = week != 0 ? week - 1 : 6;
  // 获得当前周的第一天
  const currentWeekDayOne = new Date(currentDate.getTime() - millisecond * minusDay);
  // 上周最后一天即本周开始的前一天
  const priorWeekLastDay = new Date(currentWeekDayOne.getTime() - millisecond);
  // 上周的第一天
  const priorWeekFirstDay = new Date(priorWeekLastDay.getTime() - millisecond * 6);
  // 添加至数组
  startStop.push(priorWeekFirstDay);
  startStop.push(priorWeekLastDay);
  return startStop;
}
/**     * 得到上季度的起始日期     * year 这个年应该是运算后得到的当前本季度的年份     * month 这个应该是运算后得到的当前季度的开始月份     * */
export function getPriorSeasonFirstDay(year, month) {
  const spring = 0; // 春
  const summer = 3; // 夏
  const fall = 6; // 秋
  const winter = 9; // 冬
  // 月份从0-11
  switch (
    month // 季度的其实月份
  ) {
    case spring:
      // 如果是第一季度则应该到去年的冬季
      year--;
      month = winter;
      break;
    case summer:
      month = spring;
      break;
    case fall:
      month = summer;
      break;
    case winter:
      month = fall;
      break;
  }
  return new Date(year, month, 1);
}
/**     * 得到上季度的起止日期     * **/
export function getPreviousSeason() {
  // 起止日期数组
  const startStop = [];
  const today = new Date();
  const dayMSec = 24 * 3600 * 1000;
  // 得到上一个季度的第一天
  const lastQuarterFirstDay = new Date(today.getFullYear(), today.getMonth() - 4, 1);
  // 得到本月第一天
  const nowMonthFirstDay = new Date(today.getFullYear(), today.getMonth() - 1, 1);
  // 得到上一个季度的最后一天的毫秒值
  const lastQuarterLastDayMSec = nowMonthFirstDay.getTime() - 1 * dayMSec;
  const lastQuarterLastDay = new Date(lastQuarterLastDayMSec);
  startStop.push(lastQuarterFirstDay);
  startStop.push(lastQuarterLastDay);
  return startStop;
}
/**     * 得到去年的起止日期     * **/
export function getPreviousYear() {
  // 起止日期数组
  const startStop = [];
  // 获取当前时间
  const currentDate = getCurrentDate();
  // 获得当前年份4位年
  let currentYear = currentDate.getFullYear();
  currentYear--;
  const priorYearFirstDay = new Date(currentYear, 0, 1);
  const priorYearLastDay = new Date(currentYear, 11, 1);
  // 添加至数组
  startStop.push(priorYearFirstDay);
  startStop.push(priorYearLastDay);
  return startStop;
}

export const getDate = {
  formatDateToYYYYMMDD,
  getDateAfterDays,
  today: function () {
    return formatDate(getCurrentDate().getTime() / 1000, 'yyyy-MM-dd');
  },
  month: function () {
    const current_month = getCurrentMonth().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return current_month;
  },
  yesterday: function () {
    return [formatDate(getYesterday().getTime() / 1000, 'yyyy-MM-dd')];
  },
  week: function () {
    const current_week = getCurrentWeek().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return current_week;
  },
  lastWeek: function () {
    const last_week = getPreviousWeek().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return last_week;
  },
  lastMonth: function () {
    const last_month = getPreviousMonth().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return last_month;
  },
  quarter: function () {
    const current_quarter = getCurrentSeason().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return current_quarter;
  },
  lastQuarter: function () {
    const last_quarter = getPreviousSeason().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return last_quarter;
  },
  year: function () {
    const current_year = getCurrentYear().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return current_year;
  },
  lastYear: function () {
    const last_year = getPreviousYear().map((item) => {
      return formatDate(item.getTime() / 1000, 'yyyy-MM-dd');
    });
    return last_year;
  },
};
